require 'digest/sha1'


class User < ActiveRecord::Base

# Validaciones para la creacion del user

  belongs_to:countries
  has_many :bets
  
  validates_presence_of     :login, :message => "^ El Usuario no debe estar vacio"
  validates_uniqueness_of   :login, :message => "^ El Usuario no puede estar repetido."
 
  attr_accessor :password_confirmation
  validates_confirmation_of :password
  validate :password_non_blank, 	  	  :message => "^ El Contrasena no puede estar vacio."
  validates_presence_of     :email, 	  :message => "^ El Email no puede estar vacio."
  validates_uniqueness_of   :email, 	  :message => "^ El Email no puede estar repetido."
  validates_presence_of     :name, 	  	  :message => "^ El Nombre no puede estar vacio."
  validates_format_of       :name,   	  :with => /^[a-zA-Z]+(([\'\,\.\ ][a-zA-Z])?[a-zA-Z]*)*$/, :message => "^ El Nombre solo debe contener letras."
  validates_presence_of     :lastname,	  :message => "^ El Apellido no puede estar vacio."
  validates_format_of       :lastname,     :with => /^[a-zA-Z]+(([\'\,\.\ ][a-zA-Z])?[a-zA-Z]*)*$/, :message => "^ El Apellido solo debe contener letras."
  validates_presence_of     :city, 		  :message => "^ La ciudad no puede estar vacio."
  validates_format_of       :city,   	  :with => /^[a-zA-Z]+(([\'\,\.\ ][a-zA-Z])?[a-zA-Z]*)*$/, :message => "^ La Ciudad solo debe contener letras."
  validates_presence_of     :country_idf, :message => "^ Debe Ingresar un pais para la persona."

  # Metodo para la autenticacion del user
  def self.authenticate(login, password)
    user = self.find_by_login(login)
    if user
      expected_password = encrypted_password(password, user.salt)
      if user.hashed_password != expected_password
        user = nil
      end
    end
    user
  end
  
  
  # 'password' es un atributo virtual
  
  def password
    @password
  end
  
  
  def password=(pwd)
    @password = pwd
    return if pwd.blank?
    create_new_salt
    self.hashed_password = User.encrypted_password(self.password, self.salt)
  end
  
  

private

  def password_non_blank
    errors.add(:password, "Missing password") if hashed_password.blank?
  end

  
  
  def create_new_salt
    self.salt = self.object_id.to_s + rand.to_s
  end
  
  
  
  def self.encrypted_password(password, salt)
    string_to_hash = password + "wibble" + salt
    Digest::SHA1.hexdigest(string_to_hash)
  end
  

end


